#coding:utf-8

import numpy as np
import tensorflow as tf
from sklearn import datasets
from tensorflow.python.framework import ops

ops.reset_default_graph()

sess = tf.Session()

#load the data
iris = datasets.load_iris()
x_vals = np.array([[x[0],x[3]] for x in iris.data])
y_vals1 = np.array([1 if y==0 else -1 for y in iris.target])
y_vals2 = np.array([1 if y==1 else -1 for y in iris.target])
y_vals3 = np.array([1 if y==2 else -1 for y in iris.target])
y_vals = np.array([y_vals1,y_vals2,y_vals3])
class1_x = [x[0] for i,x in enumerate(x_vals) if iris.target[i] == 0]
class1_y = [x[1] for i,x in enumerate(x_vals) if iris.target[i] == 0]
class2_x = [x[0] for i,x in enumerate(x_vals) if iris.target[i] == 1]
class2_y = [x[1] for i,x in enumerate(x_vals) if iris.target[i] == 1]
class3_x = [x[0] for i,x in enumerate(x_vals) if iris.target[i] == 2]
class3_y = [x[0] for i,x in enumerate(x_vals) if iris.target[1] == 3]

#defiend batch size
batch_size = 50

#Initalize plcaeholders
x_data = tf.placeholder(shape=[None,2],dtype=tf.float32)
y_target = tf.placeholder(shape=[3,None],dtype=tf.float32)
prediction_grid = tf.placeholder(shape=[None,2],dtype=tf.float32)

#create variable for svm
b = tf.Variable(tf.random_normal(shape=[3,batch_size]))

#Gaussian Kernel
gamma = tf.constant(-10.0)
dist = tf.reduce_sum(tf.square(x_data),1)
dist = tf.reshape(dist,[-1,1])
sq_dists = tf.multiply(2.,tf.matmul(x_data,tf.transpose(x_data)))
my_kernel = tf.exp(tf.multiply(gamma,tf.abs(sq_dists)))

#declare function to do reshape/batch multiplication
def reshpae_matmul(mat):
    v1 = tf.expand_dims(mat,1)
    v2 = tf.reshape(v1,[3,batch_size,1])
    return (tf.matmul(v2,v1))

#compute SVM Model
first_term = tf.reduce_sum(b)
b_vec_cross = tf.matmul(tf.transpose(b),b)
y_target_cross = reshpae_matmul(y_target)

second_term = tf.reduce_sum(tf.multiply(my_kernel,tf.multiply(b_vec_cross,y_target_cross)),[1,2])
loss = tf.reduce_sum(tf.negative(tf.subtract(first_term,second_term)))
#Gaussian prediction kernel
rA = tf.reshape(tf.reduce_sum(tf.square(x_data),1),[-1,1])
rB = tf.reshape(tf.reduce_sum(tf.square(prediction_grid),1),[-1,1])
pred_sq_dist = tf.add(tf.subtract(rA,tf.multiply(2.,tf.matmul(x_data,tf.transpose(prediction_grid)))),tf.transpose(rB))
pred_kernel = tf.exp(tf.multiply(gamma,tf.abs(pred_sq_dist)))

prediction_output = tf.matmul(tf.multiply(y_target,b),pred_kernel)
prediction = tf.argmax(prediction_output - tf.expand_dims(tf.reduce_mean(prediction_output,1),1),0)
accuracy = tf.reduce_mean(tf.cast(tf.equal(prediction,tf.argmax(y_target,0)),tf.float32))

#declare optimizer
my_opt = tf.train.GradientDescentOptimizer(0.01)
train_step = my_opt.minimize(loss)

#Initalize variables
init = tf.global_variables_initializer()
sess.run(init)

#training loop
loss_vec = []
batch_accuracy = []
for i in range(100):
    rand_index = np.random.choice(len(x_vals),size=batch_size)
    rand_x = x_vals[rand_index]
    rand_y = y_vals[:,rand_index]
    sess.run(train_step,feed_dict={x_data:rand_x,y_target:rand_y})

    temp_loss = sess.run(loss,feed_dict = {x_data:rand_x,y_target:rand_y})
    loss_vec.append(temp_loss)

    acc_temp =  sess.run(accuracy,feed_dict = {x_data:rand_x,y_target:rand_y,prediction_grid:rand_x})
    batch_accuracy.append(acc_temp)

    if(i+1)%25 == 0:
        print('Step #' + str(i+1))
        print('Loss = '+str(temp_loss))

# graph paint
x_min,x_max = x_vals[:,0].min()-1,x_vals[:,0].max()+1
y_min,y_max = x_vals[:,1].min()-1,x_vals[:,1].max()+1

xx,yy = np.meshgrid(np.arange(x_min,x_max,0.02),
                    np.arange(y_min,y_max,0.02))
grid_points = np.c_[xx.ravel(),yy.ravel()]
grid_predictions = sess.run(prediction,feed_dict={x_data:rand_x,
                                                  y_target:rand_y,
                                                  prediction_grid:grid_points})
grid_predictions = grid_predictions.reshape(xx.shape)

#test323232wwwww




























